home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / DistUpgrade / DistUpgradeView.py < prev    next >
Text File  |  2009-11-02  |  14KB  |  369 lines
  1. # DistUpgradeView.py 
  2. #  
  3. #  Copyright (c) 2004,2005 Canonical
  4. #  
  5. #  Author: Michael Vogt <michael.vogt@ubuntu.com>
  6. # 
  7. #  This program is free software; you can redistribute it and/or 
  8. #  modify it under the terms of the GNU General Public License as 
  9. #  published by the Free Software Foundation; either version 2 of the
  10. #  License, or (at your option) any later version.
  11. # 
  12. #  This program is distributed in the hope that it will be useful,
  13. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #  GNU General Public License for more details.
  16. # 
  17. #  You should have received a copy of the GNU General Public License
  18. #  along with this program; if not, write to the Free Software
  19. #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20. #  USA
  21.  
  22. from DistUpgradeGettext import gettext as _
  23. from DistUpgradeGettext import ngettext
  24. import subprocess
  25. from subprocess import Popen, PIPE
  26. import apt
  27. import os
  28. import apt_pkg 
  29. import signal
  30. import glob
  31. import select
  32.  
  33. from DistUpgradeAufs import doAufsChroot, doAufsChrootRsync
  34. from DistUpgradeApport import *
  35.  
  36.  
  37. def FuzzyTimeToStr(sec):
  38.   " return the time a bit fuzzy (no seconds if time > 60 secs "
  39.   #print "FuzzyTimeToStr: ", sec
  40.   sec = int(sec)
  41.  
  42.   days = sec/(60*60*24)
  43.   hours = sec/(60*60) % 24
  44.   minutes = (sec/60) % 60
  45.   seconds = sec % 60
  46.   # 0 seonds remaining looks wrong and its "fuzzy" anyway
  47.   if seconds == 0:
  48.     seconds = 1
  49.  
  50.   # string map to make the re-ordering possible
  51.   map = { "str_days" : "",
  52.           "str_hours" : "",
  53.           "str_minutes" : "",
  54.           "str_seconds" : ""
  55.         }
  56.   
  57.   # get the fragments, this is not ideal i18n wise, but its
  58.   # difficult to do it differently
  59.   if days > 0:
  60.     map["str_days"] = ngettext("%li day","%li days", days) % days
  61.   if hours > 0:
  62.     map["str_hours"] = ngettext("%li hour","%li hours", hours) % hours
  63.   if minutes > 0:
  64.     map["str_minutes"] = ngettext("%li minute","%li minutes", minutes) % minutes
  65.   map["str_seconds"] = ngettext("%li second","%li seconds", seconds) % seconds
  66.  
  67.   # now assemble the string
  68.   if days > 0:
  69.     # TRANSLATORS: you can alter the ordering of the remaining time
  70.     # information here if you shuffle %(str_days)s %(str_hours)s %(str_minutes)s
  71.     # around. Make sure to keep all '$(str_*)s' in the translated string
  72.     # and do NOT change anything appart from the ordering.
  73.     #
  74.     # %(str_hours)s will be either "1 hour" or "2 hours" depending on the
  75.     # plural form
  76.     # 
  77.     # Note: most western languages will not need to change this
  78.     return _("%(str_days)s %(str_hours)s") % map
  79.   # display no minutes for time > 3h, see LP: #144455
  80.   elif hours > 3:
  81.     return map["str_hours"]
  82.   # when we are near the end, become more precise again
  83.   elif hours > 0:
  84.     # TRANSLATORS: you can alter the ordering of the remaining time
  85.     # information here if you shuffle %(str_hours)s %(str_minutes)s
  86.     # around. Make sure to keep all '$(str_*)s' in the translated string
  87.     # and do NOT change anything appart from the ordering.
  88.     #
  89.     # %(str_hours)s will be either "1 hour" or "2 hours" depending on the
  90.     # plural form
  91.     # 
  92.     # Note: most western languages will not need to change this
  93.     return _("%(str_hours)s %(str_minutes)s") % map
  94.   elif minutes > 0:
  95.     return map["str_minutes"]
  96.   return map["str_seconds"]
  97.  
  98.  
  99. class FetchProgress(apt.progress.FetchProgress):
  100.   def __init__(self):
  101.     #print "init FetchProgress in DistUpgradeView"
  102.     apt.progress.FetchProgress.__init__(self)
  103.     self.est_speed = 0
  104.   def start(self):
  105.     self.release_file_download_error = False
  106.   def updateStatus(self, uri, descr, shortDescr, status):
  107.     # FIXME: workaround issue in libapt/python-apt that does not 
  108.     #        raise a exception if *all* files fails to download
  109.     if status == self.dlFailed:
  110.       logging.warn("updateStatus: dlFailed on '%s' " % uri)
  111.       if uri.endswith("Release.gpg") or uri.endswith("Release"):
  112.         # only care about failures from network, not gpg, bzip, those
  113.         # are different issues
  114.         for net in ["http","ftp","mirror"]:
  115.           if uri.startswith(net):
  116.             self.release_file_download_error = True
  117.             break
  118.   def pulse(self):
  119.     apt.progress.FetchProgress.pulse(self)
  120.     if self.currentCPS > self.est_speed:
  121.       self.est_speed = (self.est_speed+self.currentCPS)/2.0
  122.     return True
  123.   def estimatedDownloadTime(self, requiredDownload):
  124.     """ get the estimated download time """
  125.     if self.est_speed == 0:
  126.       timeModem = requiredDownload/(56*1024/8)  # 56 kbit 
  127.       timeDSL = requiredDownload/(1024*1024/8)  # 1Mbit = 1024 kbit
  128.       s= _("This download will take about %s with a 1Mbit DSL connection "
  129.            "and about %s with a 56k modem.") % (FuzzyTimeToStr(timeDSL), FuzzyTimeToStr(timeModem))
  130.       return s
  131.     # if we have a estimated speed, use it
  132.     s = _("This download will take about %s with your connection. ") % FuzzyTimeToStr(requiredDownload/self.est_speed)
  133.     return s
  134.     
  135.  
  136.  
  137. class InstallProgress(apt.progress.InstallProgress):
  138.   """ Base class for InstallProgress that supports some fancy
  139.       stuff like apport integration
  140.   """
  141.   def __init__(self):
  142.     apt.progress.InstallProgress.__init__(self)
  143.     self.master_fd = None
  144.  
  145.   def waitChild(self):
  146.       """Wait for child progress to exit.
  147.  
  148.       The return values is the full status returned from os.waitpid()
  149.       (not only the return code).
  150.       """
  151.       while True:
  152.           try:
  153.               select.select([self.statusfd], [], [], self.selectTimeout)
  154.           except select.error, (errno_, errstr):
  155.               if errno_ != errno.EINTR:
  156.                   raise
  157.           self.updateInterface()
  158.           try:
  159.               (pid, res) = os.waitpid(self.child_pid, os.WNOHANG)
  160.               if pid == self.child_pid:
  161.                   break
  162.           except OSError, (errno_, errstr):
  163.               if errno_ != errno.EINTR:
  164.                   raise
  165.               if errno_ == errno.ECHILD:
  166.                   break
  167.       return res
  168.  
  169.   def run(self, pm):
  170.     pid = self.fork()
  171.     if pid == 0:
  172.       # check if we need to setup/enable the aufs chroot stuff
  173.       if "RELEASE_UPGRADE_USE_AUFS_CHROOT" in os.environ:
  174.         if not doAufsChroot(os.environ["RELEASE_UPGRADE_AUFS_RWDIR"],
  175.                             os.environ["RELEASE_UPGRADE_USE_AUFS_CHROOT"]):
  176.           print "ERROR: failed to setup aufs chroot overlay"
  177.           os._exit(1)
  178.       # child, ignore sigpipe, there are broken scripts out there
  179.       # like etckeeper (LP: #283642)
  180.       signal.signal(signal.SIGPIPE,signal.SIG_IGN) 
  181.       try:
  182.         res = pm.DoInstall(self.writefd)
  183.       except Exception, e:
  184.         print "Exception during pm.DoInstall(): ", e
  185.         logging.exception("Exception during pm.DoInstall()")
  186.         os._exit(pm.ResultFailed)
  187.       os._exit(res)
  188.     self.child_pid = pid
  189.     res = os.WEXITSTATUS(self.waitChild())
  190.     # check if we want to sync the changes back, *only* do that
  191.     # if res is positive
  192.     if (res == 0 and
  193.         "RELEASE_UPGRADE_RSYNC_AUFS_CHROOT" in os.environ):
  194.       logging.info("doing rsync commit of the update")
  195.       if not doAufsChrootRsync(os.environ["RELEASE_UPGRADE_USE_AUFS_CHROOT"]):
  196.         logging.error("FATAL ERROR: doAufsChrootRsync() returned FALSE")
  197.         return pm.ResultFailed
  198.     return res
  199.   
  200.   def error(self, pkg, errormsg):
  201.     " install error from a package "
  202.     apt.progress.InstallProgress.error(self, pkg, errormsg)
  203.     logging.error("got an error from dpkg for pkg: '%s': '%s'" % (pkg, errormsg))
  204.     if "/" in pkg:
  205.       pkg = os.path.basename(pkg)
  206.     if "_" in pkg:
  207.       pkg = pkg.split("_")[0]
  208.     # now run apport
  209.     apport_pkgfailure(pkg, errormsg)
  210.  
  211. class DumbTerminal(object):
  212.     def call(self, cmd, hidden=False):
  213.         " expects a command in the subprocess style (as a list) "
  214.         import subprocess
  215.         subprocess.call(cmd)
  216.  
  217.  
  218. (STEP_PREPARE,
  219.  STEP_MODIFY_SOURCES,
  220.  STEP_FETCH,
  221.  STEP_INSTALL,
  222.  STEP_CLEANUP,
  223.  STEP_REBOOT,
  224.  STEP_N) = range(1,8)
  225.  
  226. ( _("Preparing to upgrade"),
  227.   _("Getting new software channels"),
  228.   _("Getting new packages"),
  229.   _("Installing the upgrades"),
  230.   _("Cleaning up"),
  231. )
  232.  
  233. class DistUpgradeView(object):
  234.     " abstraction for the upgrade view "
  235.     def __init__(self):
  236.         pass
  237.     def getOpCacheProgress(self):
  238.         " return a OpProgress() subclass for the given graphic"
  239.         return apt.progress.OpProgress()
  240.     def getFetchProgress(self):
  241.         " return a fetch progress object "
  242.         return FetchProgress()
  243.     def getInstallProgress(self, cache=None):
  244.         " return a install progress object "
  245.         return InstallProgress()
  246.     def getTerminal(self):
  247.         return DumbTerminal()
  248.     def updateStatus(self, msg):
  249.         """ update the current status of the distUpgrade based
  250.             on the current view
  251.         """
  252.         pass
  253.     def abort(self):
  254.         """ provide a visual feedback that the upgrade was aborted """
  255.         pass
  256.     def setStep(self, step):
  257.         """ we have 6 steps current for a upgrade:
  258.         1. Analyzing the system
  259.         2. Updating repository information
  260.         3. fetch packages
  261.         3. Performing the upgrade
  262.         4. Post upgrade stuff
  263.         5. Complete
  264.         """
  265.         pass
  266.     def hideStep(self, step):
  267.         " hide a certain step from the GUI "
  268.         pass
  269.     def showStep(self, step):
  270.         " show a certain step from the GUI "
  271.         pass
  272.     def confirmChanges(self, summary, changes, downloadSize,
  273.                        actions=None, removal_bold=True):
  274.         """ display the list of changed packages (apt.Package) and
  275.             return if the user confirms them
  276.         """
  277.         self.confirmChangesMessage = ""
  278.         self.toInstall = []
  279.         self.toUpgrade = []
  280.         self.toRemove = []
  281.         self.toDowngrade = []
  282.         for pkg in changes:
  283.             if pkg.markedInstall: self.toInstall.append(pkg.name)
  284.             elif pkg.markedUpgrade: self.toUpgrade.append(pkg.name)
  285.             elif pkg.markedDelete: self.toRemove.append(pkg.name)
  286.             elif pkg.markedDowngrade: self.toDowngrade.append(pkg.name)
  287.         # sort it
  288.         self.toInstall.sort()
  289.         self.toUpgrade.sort()
  290.         self.toRemove.sort()
  291.         self.toDowngrade.sort()
  292.         # no re-installs 
  293.         assert(len(self.toInstall)+len(self.toUpgrade)+len(self.toRemove)+len(self.toDowngrade) == len(changes))
  294.         # now build the message (the same for all frontends)
  295.         msg = "\n"
  296.         pkgs_remove = len(self.toRemove)
  297.         pkgs_inst = len(self.toInstall)
  298.         pkgs_upgrade = len(self.toUpgrade)
  299.         # FIXME: show detailed packages
  300.         if pkgs_remove > 0:
  301.           # FIXME: make those two separate lines to make it clear
  302.           #        that the "%" applies to the result of ngettext
  303.           msg += ngettext("%d package is going to be removed.",
  304.                           "%d packages are going to be removed.",
  305.                           pkgs_remove) % pkgs_remove
  306.           msg += " "
  307.         if pkgs_inst > 0:
  308.           msg += ngettext("%d new package is going to be "
  309.                           "installed.",
  310.                           "%d new packages are going to be "
  311.                           "installed.",pkgs_inst) % pkgs_inst
  312.           msg += " "
  313.         if pkgs_upgrade > 0:
  314.           msg += ngettext("%d package is going to be upgraded.",
  315.                           "%d packages are going to be upgraded.",
  316.                           pkgs_upgrade) % pkgs_upgrade
  317.           msg +=" "
  318.         if downloadSize > 0:
  319.           msg += _("\n\nYou have to download a total of %s. ") %\
  320.               apt_pkg.SizeToStr(downloadSize)
  321.           msg += self.getFetchProgress().estimatedDownloadTime(downloadSize)
  322.         if (pkgs_upgrade + pkgs_inst + pkgs_remove) > 100:
  323.           msg += "\n\n%s" % _( "Fetching and installing the upgrade "
  324.                                "can take several hours. Once the download "
  325.                                "has finished, the process cannot be cancelled.")
  326.         # Show an error if no actions are planned
  327.         if (pkgs_upgrade + pkgs_inst + pkgs_remove) < 1:
  328.           # FIXME: this should go into DistUpgradeController
  329.           summary = _("Your system is up-to-date")
  330.           msg = _("There are no upgrades available for your system. "
  331.                   "The upgrade will now be canceled.")
  332.           self.error(summary, msg)
  333.           return False
  334.         # set the message
  335.         self.confirmChangesMessage = msg
  336.         return True
  337.  
  338.     def askYesNoQuestion(self, summary, msg, default='No'):
  339.         " ask a Yes/No question and return True on 'Yes' "
  340.         pass
  341.     def confirmRestart(self):
  342.         " generic ask about the restart, can be overridden "
  343.         summary = _("Reboot required")
  344.         msg =  _("The upgrade is finished and "
  345.                  "a reboot is required. "
  346.                  "Do you want to do this "
  347.                  "now?")
  348.         return self.askYesNoQuestion(summary, msg)
  349.     def error(self, summary, msg, extended_msg=None):
  350.         " display a error "
  351.         pass
  352.     def information(self, summary, msg, extended_msg=None):
  353.         " display a information msg"
  354.         pass
  355.     def processEvents(self):
  356.         """ process gui events (to keep the gui alive during a long
  357.             computation """
  358.         pass
  359.     def showDemotions(self, summary, msg, demotions):
  360.       """
  361.       show demoted packages to the user, default implementation
  362.       is to just show a information dialog
  363.       """
  364.       self.information(summary, msg, "\n".join(demotions))
  365.  
  366. if __name__ == "__main__":
  367.   fp = FetchProgress()
  368.   fp.pulse()
  369.